home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 2000 August: Tool Chest / Dev.CD Aug 00 TC Disk 2.toast / pc / sample code / interapplication comm / 7edit / source / sveditutils.c < prev    next >
Encoding:
C/C++ Source or Header  |  2000-06-23  |  17.1 KB  |  623 lines
  1. /*
  2.     File:        SVEditUtils.c
  3.  
  4.     Contains:    
  5.  
  6.     Written by: Original version by Jon Lansdell and Nigel Humphreys.
  7.                             3.1 updates by Greg Sutton.    
  8.  
  9.     Copyright:    Copyright ©1995-1999 by Apple Computer, Inc., All Rights Reserved.
  10.  
  11.                 You may incorporate this Apple sample source code into your program(s) without
  12.                 restriction. This Apple sample source code has been provided "AS IS" and the
  13.                 responsibility for its operation is yours. You are not permitted to redistribute
  14.                 this Apple sample source code as "Apple sample source code" after having made
  15.                 changes. If you're going to re-distribute the source, we require that you make
  16.                 it clear in the source that the code was descended from Apple sample source
  17.                 code, but that you've made changes.
  18.  
  19.     Change History (most recent first):
  20.                 7/19/1999    Karl Groethe    Updated for Metrowerks Codewarror Pro 2.1
  21.                 10/12/95    CW                        Simplified FeatureIsImplemented routine.
  22.                                                                Added init of gHasDragManager flag in CheckEnvironment.
  23.                 
  24.  
  25. */
  26.  
  27. #include <DriverServices.h>
  28. #include <Events.h>
  29. #include <Traps.h>
  30. #include <Dialogs.h>
  31. #include <Fonts.h>
  32. #include <Packages.h>
  33. #include <ToolUtils.h>
  34. #include <AppleEvents.h>
  35. #include <CodeFragments.h>
  36. #include "SVEditUtils.h"
  37. #include <TextUtils.h>
  38.  
  39. /**-----------------------------------------------------------------------
  40.         Name:             LesserOf
  41.         Purpose:        Returns the Lesser of two longints.
  42.     -----------------------------------------------------------------------**/
  43. #pragma segment Utils
  44.         
  45. pascal long LesserOf(long A, long B)
  46.  {
  47.    if (A<B)
  48.        return(A);
  49.      else
  50.        return(B);
  51.  }   /*LesserOf*/
  52.             
  53. /**-----------------------------------------------------------------------
  54.         Name:             GreaterOf
  55.         Purpose:        Returns the Greater of two longints.
  56.     -----------------------------------------------------------------------**/
  57.     
  58. #pragma segment Utils
  59.         
  60. pascal long GreaterOf(long A, long B)
  61.  {
  62.    if (A>B)
  63.        return(A);
  64.      else
  65.        return(B);
  66.  }  /*GreaterOf*/
  67.             
  68. /**-----------------------------------------------------------------------
  69.         Name:             ShowError
  70.         Purpose:        Reports an error to the user as both string and number.
  71.     -----------------------------------------------------------------------**/
  72. #pragma segment Utils
  73.         
  74. pascal void ShowError(Str255  theError,
  75.                                           long    theErrorCode)
  76. {
  77.    short     alertResult;
  78.    Str255    theString;
  79.      OSErr     myErr;
  80.      
  81.      myErr = AEInteractWithUser(kAEDefaultTimeout, nil,nil);
  82.      
  83.      if (myErr == noErr)
  84.        {
  85.              SetCursor(&qd.arrow);
  86.              NumToString(theErrorCode, theString);
  87.              ParamText(theError, theString, (unsigned char *)"", (unsigned char *)"");
  88.              alertResult = Alert(300, nil);
  89.          }
  90. } /* ShowError */
  91.  
  92. /**-----------------------------------------------------------------------
  93.         Name:             Ours
  94.         Purpose:        Checks the frontmost window belongs to the app.
  95.     -----------------------------------------------------------------------**/
  96. #pragma segment Utils        
  97.     
  98. pascal Boolean Ours(WindowPtr aWindow)
  99.  {
  100.         if (aWindow)
  101.             if (((WindowPeek)aWindow)->windowKind == zoomDocProc)
  102.                 return(true);
  103.         return(false);
  104. } /* Ours */
  105.  
  106. /**-----------------------------------------------------------------------
  107.         Name:             SetShortMenus
  108.         Purpose:        Cuts the menus down to a minimum - Apple File Edit.
  109.                                 Greys out the unavailable options - used when no docs open
  110.     -----------------------------------------------------------------------**/
  111. #pragma segment Utils        
  112.  
  113. pascal void SetShortMenus()
  114. { 
  115.     DeleteMenu(mfontID);
  116.     DeleteMenu(sizeID);
  117.     DeleteMenu(styleID);
  118.  
  119.     DisableItem(myMenus[fileM], fmClose);
  120.     DisableItem(myMenus[fileM], fmSave);
  121.     DisableItem(myMenus[fileM], fmSaveAs);
  122.     DisableItem(myMenus[fileM], fmRevert);
  123.     DisableItem(myMenus[fileM], fmPageSetUp);
  124.     DisableItem(myMenus[fileM], fmNoGXPrint);
  125.  
  126.     /* now the unnecessary items on the edit menu */
  127.                 
  128.     DisableItem(myMenus[editM], undoCommand);
  129.     DisableItem(myMenus[editM], cutCommand);
  130.     DisableItem(myMenus[editM], copyCommand);
  131.     DisableItem(myMenus[editM], clearCommand);
  132.     DisableItem(myMenus[editM], pasteCommand);
  133.     DisableItem(myMenus[editM], selectAllCommand);
  134.  
  135.     DrawMenuBar();
  136. }  /* SetShortMenus */
  137.  
  138. /**-----------------------------------------------------------------------
  139.         Name:             SetLongMenus
  140.         Purpose:        Reinstates the full menu bar - called when first document
  141.                     opened.
  142.     -----------------------------------------------------------------------**/
  143. #pragma segment Utils        
  144.  
  145. pascal void SetLongMenus()
  146.   {
  147.         InsertMenu(myMenus[fontM], 0);
  148.         InsertMenu(myMenus[sizeM], 0);
  149.         InsertMenu(myMenus[styleM], 0);
  150.  
  151.         EnableItem(myMenus[fileM], fmClose);
  152.         EnableItem(myMenus[fileM], fmSave);
  153.         EnableItem(myMenus[fileM], fmSaveAs);
  154.         EnableItem(myMenus[fileM], fmRevert);
  155.         EnableItem(myMenus[fileM], fmPageSetUp);
  156.  
  157.         EnableItem(myMenus[fileM], fmNoGXPrint );
  158.  
  159.         /* now the necessary items on the edit menu -
  160.             many other items fixed on each pass thru the main event
  161.             loop or before the window pulled down
  162.         */
  163.         
  164.         EnableItem(myMenus[editM], selectAllCommand);
  165.  
  166.         DrawMenuBar();
  167.     }  /* SetLongMenus */
  168.  
  169. /**-----------------------------------------------------------------------
  170.         Name:             SetStyleMenu
  171.         Purpose:        Sets the style menu checking to reflect the style of the
  172.                     first character of the current selection in the given
  173.                                 document.
  174.     -----------------------------------------------------------------------**/
  175. #pragma segment Utils        
  176.         
  177. pascal void SetStyleMenu(DPtr theDoc)
  178.   {
  179.     TextStyle        theTStyle;
  180.         short       contMode;
  181.         short       i;
  182.         
  183.         contMode = doFace;
  184.         
  185.         TEContinuousStyle(&contMode,&theTStyle,theDoc->theText);
  186.         
  187.         if ((contMode & doFace) != 0)
  188.             {
  189.                 CheckItem(myMenus[styleM], cPlain,     (theTStyle.tsFace == 0));
  190.                 CheckItem(myMenus[styleM], cBold,      (bold      & theTStyle.tsFace));
  191.                 CheckItem(myMenus[styleM], cItalic,    (italic    & theTStyle.tsFace));
  192.                 CheckItem(myMenus[styleM], cUnderline, (underline & theTStyle.tsFace));
  193.                 CheckItem(myMenus[styleM], cOutline,   (outline   & theTStyle.tsFace));
  194.                 CheckItem(myMenus[styleM], cShadow,    (shadow    & theTStyle.tsFace));
  195.                 CheckItem(myMenus[styleM], cCondense,  (condense  & theTStyle.tsFace));
  196.                 CheckItem(myMenus[styleM], cExtend,    (extend    & theTStyle.tsFace));
  197.           }
  198.         else
  199.             for (i=cPlain; i<= cExtend; i++)
  200.                 CheckItem(myMenus[styleM], i,     false);
  201.   }
  202.  
  203. /**-----------------------------------------------------------------------
  204.     Name:       SetSizeMenu
  205.     Purpose:    Outline all the items if the current font is an
  206.                 outline font. Check the size of the current selection
  207.   -----------------------------------------------------------------------**/
  208. #pragma segment Utils        
  209.  
  210. pascal void SetSizeMenu(DPtr theDoc)
  211.   {
  212.       short             i;
  213.         short                aSize;
  214.         short                max;
  215.     long                 theSize;
  216.     Str255        name;
  217.     Boolean       sizeinMenu;
  218.     Boolean       oldState;
  219.     Point         numer;
  220.     TextStyle        theStyle;
  221.         TEHandle    myText;
  222.         short       contMode;
  223.       
  224.     numer.h = 1;
  225.     numer.v = 1;
  226.  
  227.     myText = theDoc->theText;
  228.         
  229.         contMode = doSize+doFont;
  230.         
  231.         TEContinuousStyle(&contMode,&theStyle,theDoc->theText);
  232.         
  233.     sizeinMenu = false;
  234.     max = CountMItems(myMenus[sizeM]);
  235.         for (i = 1; i <= max - 5; i++)
  236.       {
  237.                 GetMenuItemText(myMenus[sizeM], i, name);
  238.                 StringToNum(name, &theSize);
  239.                 aSize = (short)theSize;
  240.  
  241.                 if (RealFont(theStyle.tsFont, aSize) && (contMode & doFont) != 0) // there is only one font and this size exists
  242.                     SetItemStyle(myMenus[sizeM], i, outline);
  243.                 else
  244.                     SetItemStyle(myMenus[sizeM], i, 0);
  245.  
  246.                 if ((aSize == theStyle.tsSize) && (contMode & doSize) != 0)
  247.                     {
  248.                         sizeinMenu = true;
  249.                         CheckItem(myMenus[sizeM], i, true);
  250.                     }
  251.                 else
  252.                     CheckItem(myMenus[sizeM], i, false);
  253.             }
  254.         
  255.             /*
  256.                 if it's not a size in the menu,and there is only one size in the
  257.               selection range check the other item
  258.             */
  259.             
  260.             if (!sizeinMenu && (contMode & doSize) != 0)
  261.               CheckItem(myMenus[sizeM], max, true);
  262.             else
  263.                 CheckItem(myMenus[sizeM], max, false);
  264.  
  265.             /*if this is an outline font, set the rest of the items to outline style*/
  266.             /*RealFont will ensure that the sizes are outlined*/
  267.  
  268.             oldState = GetOutlinePreferred();
  269.             SetOutlinePreferred(true);
  270.             for (i = max-4; i <= max; i++)
  271.                 {
  272.                     if (IsOutline(numer, numer) && (contMode & doFont)!= 0)
  273.                         SetItemStyle(myMenus[sizeM], i, outline);
  274.                     else
  275.                         SetItemStyle(myMenus[sizeM], i, 0);
  276.                 }
  277.                 
  278.             SetOutlinePreferred(oldState);
  279.     }
  280.  
  281. /**-----------------------------------------------------------------------
  282.     Name:       SetFontMenu
  283.     Purpose:    Set the font menu according to the state of
  284.                                 current selection of the supplied document.
  285.   -----------------------------------------------------------------------**/
  286. #pragma segment Utils
  287.         
  288. pascal void SetFontMenu(DPtr theDoc)
  289.   {
  290.     MenuHandle        theMHandle;
  291.     short         theNumber;
  292.     short         i;
  293.     short                max;
  294.     Str255        name;
  295.     TextStyle     theStyle;
  296.         short         contMode;
  297.  
  298.         theMHandle = GetMenuHandle(mfontID);
  299.  
  300.         if (gFontMItem)
  301.       CheckItem(theMHandle, gFontMItem, false);
  302.             
  303.         max = CountMItems(theMHandle);
  304.  
  305.         contMode = doFont;
  306.         TEContinuousStyle(&contMode,&theStyle,theDoc->theText);
  307.  
  308.         gFontMItem = 0;
  309.         
  310.     if (contMode & doFont)
  311.             for (i=1; i<=max; i++)
  312.                 {
  313.                     GetMenuItemText(theMHandle, i, name);
  314.                     GetFNum(name, &theNumber);
  315.                     if (theNumber == theStyle.tsFont)
  316.                         gFontMItem = i;
  317.                 }
  318.  
  319.     if (gFontMItem)
  320.       CheckItem(theMHandle, gFontMItem, true);
  321.             
  322.         SetSizeMenu(theDoc);
  323.         SetStyleMenu(theDoc);
  324.     }
  325.  
  326. /**-----------------------------------------------------------------------
  327.     Name:       GetTempFileName
  328.     Purpose:    Fills newstring with a temporary file name.
  329.   -----------------------------------------------------------------------**/
  330.  
  331. #pragma segment Utils
  332.  
  333. pascal void GetTempFileName(DPtr aDoc,
  334.                             Str255 newString)
  335.  
  336.     {
  337.        Str255        s;
  338.      Str255        fileName;
  339.  
  340.         if (aDoc->everSaved == false)
  341.           PStrCopy(fileName, (unsigned char *)"\pTEXTra");
  342.         else
  343.             PStrCopy(fileName, aDoc->theFileName);
  344.  
  345.     /*generate a unique(ish) temporary filename*/
  346.         
  347.         if (fileName[0] > 21)
  348.           fileName[0] = 21;
  349.                 
  350.         NumToString(TickCount(), s);
  351.         
  352.         PStrCat(fileName, s);
  353.         
  354.         PStrCopy(newString,fileName);
  355.     }
  356.  
  357. /**-----------------------------------------------------------------------
  358.     Name:       SetText
  359.     Purpose:    Sets the text of the supplied itemNo in aDialog to 
  360.                                 theString and select it.
  361.   -----------------------------------------------------------------------**/
  362.  
  363. #pragma segment Utils
  364.  
  365. pascal void SetText(DialogPtr aDialog,
  366.                     short     itemNo,
  367.                     Str255    theString)
  368.   {
  369.     Handle      itemHandle;
  370.     Rect        box;
  371.     short       kind;
  372.     TEHandle    theTEHandle;
  373.  
  374.         GetDialogItem(aDialog, itemNo, &kind, &itemHandle, &box);
  375.         SetDialogItemText(itemHandle, theString);
  376.         
  377.         theTEHandle = ((DialogPeek)aDialog)->textH;
  378.  
  379.         /*set all the text to be selected*/
  380.         if (theTEHandle)
  381.             TESetSelect(0, 255, theTEHandle);
  382.     }
  383.             
  384. /**-----------------------------------------------------------------------
  385.     Name:       RetrieveText
  386.     Purpose:    Returns the text of anItem in aDialog in aString.
  387.   -----------------------------------------------------------------------**/
  388.  
  389. #pragma segment Utils
  390.  
  391. pascal void RetrieveText(DialogPtr aDialog,
  392.                                                short     anItem,
  393.                                                Str255    aString)
  394.   {
  395.      short      kind;
  396.      Rect       box;
  397.      Handle     itemHandle;
  398.  
  399.          GetDialogItem(aDialog, anItem, &kind, &itemHandle, &box);
  400.          GetDialogItemText(itemHandle, aString);
  401.   }
  402.  
  403. /**-----------------------------------------------------------------------
  404.     Name:       DrawDefaultOutline
  405.     Purpose:    Draws an outline around theItem.
  406.                                 Called as a useritem Proc by the dialog manager.
  407.                                 To use place a useritem over the default item in the
  408.                                 dialog and install the address of this proc as the item
  409.                                 handle.
  410.   -----------------------------------------------------------------------**/
  411.  
  412. #pragma segment Utils
  413.  
  414. pascal void DrawDefaultOutline(DialogPtr theDialog, short theItem)
  415.   {
  416.       short       kind;
  417.     Handle      itemHandle;
  418.     Rect        box;
  419.                 
  420.     GetDialogItem(theDialog, theItem, &kind, &itemHandle, &box);
  421.     PenSize(3, 3);
  422.     InsetRect(&box, - 4, - 4);
  423.     FrameRoundRect(&box, 16, 16);
  424.     PenNormal();
  425.         
  426.     }  /* DrawDefaultOutline */
  427.             
  428. /**-----------------------------------------------------------------------
  429.     Name:       AdornDefaultButton
  430.     Purpose:    Installs DrawDefaultOutline as the useritem proc
  431.                     for the given item.
  432.   -----------------------------------------------------------------------**/
  433.  
  434. #pragma segment Utils
  435.         
  436. pascal void AdornDefaultButton(DialogPtr theDialog,short theItem)
  437.   {
  438.       short       kind;
  439.     Handle      itemHandle;
  440.     Rect        box;
  441.  
  442.         GetDialogItem(theDialog, theItem, &kind, &itemHandle, &box);
  443.         SetDialogItem(theDialog, theItem, kind, (Handle)gDefaultButtonUPP, &box);
  444.   }
  445.  
  446.     /*-------  Determining of Gestalt is available ---------------*/
  447.     /*The following routines come from the Inside Mac VI recommendations*/
  448.     /*about how to find if a trap is available*/
  449.          /*
  450.             The glue for Gestalt will be in MPW 3.2, so if it is available we will also
  451.              need to check the system version
  452.         */
  453.  
  454. pascal void GetRectOfDialogItem(DialogPtr theDialog, short theItem, Rect *theRect)
  455.     {
  456.       short       kind;
  457.     Handle      itemHandle;
  458.         
  459.         GetDialogItem(theDialog, theItem, &kind, &itemHandle, theRect);
  460.     }
  461.  
  462. #pragma segment Utils
  463.  
  464. pascal short NumToolboxTraps(void)
  465.   {
  466.         if (NGetTrapAddress(_InitGraf, ToolTrap) == NGetTrapAddress(0xAA6E, ToolTrap))
  467.             return(0x200);
  468.         else
  469.             return(0x400);
  470.     }
  471.  
  472. #pragma segment Utils
  473.  
  474. #define TrapMask  0x0800
  475.  
  476. pascal TrapType GetTrapType(short theTrap)
  477.   {
  478.         if ((theTrap & TrapMask) > 0)
  479.             return(ToolTrap);
  480.         else
  481.             return(OSTrap);
  482.     }
  483.  
  484. #pragma segment Utils
  485.  
  486. pascal Boolean TrapAvailable(short theTrap)
  487.   {
  488.         TrapType  tType;
  489.  
  490.         tType = GetTrapType(theTrap);
  491.         if (tType == ToolTrap)
  492.             {
  493.                 theTrap = theTrap & 0x07FF;
  494.                 if (theTrap >= NumToolboxTraps())
  495.                     theTrap = _Unimplemented;
  496.             }
  497.         return(NGetTrapAddress(theTrap, tType) != NGetTrapAddress(_Unimplemented,ToolTrap));
  498.     }
  499.  
  500. #pragma segment Utils
  501.  
  502. #define _Gestalt 0xA1AD
  503.  
  504. pascal Boolean GestaltAvailable()
  505.   {
  506.         return(TrapAvailable(_Gestalt));
  507.     }
  508.  
  509. /**------  FeatureIsImplemented    ------------**/
  510. /*This is called to use Gestalt to determine if a feature is implemented.
  511.  This applies to only those referenced by OSType*/
  512.  
  513. #pragma segment Utils
  514.  
  515.  
  516. pascal Boolean FeatureIsImplemented ( OSType theFeature, short theTestBit )
  517. {
  518.     OSErr     err;
  519.     long      result;
  520.  
  521.     err = Gestalt ( theFeature, &result );
  522.     return (err == noErr && (result & (1L << theTestBit)));
  523.     
  524. }
  525.  
  526.  
  527.  
  528.  
  529. #pragma segment Utils
  530.  
  531. pascal Boolean CheckEnvironment()
  532.   {
  533.         /*
  534.          first determine of Gestalt is available- if it isn't exit
  535.          as we only run under 7.0.  It could it present in 6.04 - so we need
  536.          to do some further checks for important features
  537.         */
  538.  
  539.         gGestaltAvailable = GestaltAvailable();
  540.         
  541.         if (!gGestaltAvailable)
  542.             return(false);
  543.  
  544.     /*first check if the Edition Manager is present*/
  545.                 
  546.     gEditionManagerImplemented = FeatureIsImplemented(gestaltEditionMgrAttr,
  547.                                                                                                           gestaltEditionMgrPresent);
  548.  
  549.         /*and for good measure- the Alias manager*/
  550.                 
  551.         gAliasManagerImplemented  = FeatureIsImplemented(gestaltAliasMgrAttr,
  552.                                                                                                          gestaltAliasMgrPresent);
  553.             
  554.         /*check for the AppleEvents manager - we certainly can't work without it*/
  555.         
  556.         gAppleEventsImplemented   = FeatureIsImplemented(gestaltAppleEventsAttr,
  557.                                                                                                          gestaltAppleEventsPresent);
  558.         
  559.         /*check if recording is implemented*/
  560.         
  561.         gRecordingImplemented   = FeatureIsImplemented(gestaltAppleEventsAttr,1);
  562.             
  563.         /*check for the Outline fonts*/
  564.         
  565.         gOutlineFontsImplemented  = FeatureIsImplemented(gestaltFontMgrAttr,
  566.                                                                                                          gestaltOutlineFonts);
  567.         
  568.     
  569.     // We would also like the Drag Manager
  570.     gHasDragManager = FeatureIsImplemented ( gestaltDragMgrAttr, gestaltDragMgrPresent );
  571.     
  572.     // It isn't enough to use Gestalt because we may not have sucessfully linked
  573.     // to the DragLib shared library. So, we also need to test one of the symbols
  574.     // against kUnresolvedSymbol to make sure we have a valid connection to it.
  575.     
  576. #if GENERATINGCFM
  577.     if ( gHasDragManager )
  578.         gHasDragManager = (InstallTrackingHandler != (void*) kUnresolvedCFragSymbolAddress);
  579. #endif
  580.  
  581.  
  582.         return (gEditionManagerImplemented &&
  583.                         gAliasManagerImplemented   &&
  584.                         gAppleEventsImplemented    &&
  585.                         gOutlineFontsImplemented);
  586.                                 
  587.     }  /* CheckEnvironment */
  588.             
  589.     /*
  590.         DoPageSetup returns true if the page setup of the document is altered
  591.     */
  592.     
  593.     pascal Boolean DoPageSetup(DPtr theDoc)
  594.         {
  595.             Boolean result = false;
  596.                 if (theDoc)
  597.                         {
  598.                             PrOpen();
  599.                             result =  PrStlDialog(theDoc->thePrintSetup);
  600.                             PrClose();
  601.                         }
  602.                     
  603.                 return(result);
  604.         }  /* DoPageSetup */
  605.  
  606. /*
  607.     Name:    CtrlKeyPressed
  608.     Purpose: Returns true if control key pressed during event
  609. */
  610. pascal Boolean CtrlKeyPressed(const EventRecord *theEvent)
  611.     {
  612.         return((theEvent->modifiers & controlKey) != 0);
  613.     }
  614.     
  615. /*
  616.     Name:    OptionKeyPressed
  617.     Purpose: Returns true if option key pressed during event
  618. */
  619. pascal Boolean OptionKeyPressed(const EventRecord *theEvent)
  620.     {
  621.         return((theEvent->modifiers & optionKey) != 0);
  622.     }
  623.